home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2010 April / PCWorld0410.iso / hity wydania / Ubuntu 9.10 PL / karmelkowy-koliberek-desktop-9.10-i386-PL.iso / casper / filesystem.squashfs / usr / share / ibus-table / engine / speedmeter.py < prev    next >
Encoding:
Python Source  |  2009-07-30  |  12.5 KB  |  385 lines
  1. #!/usr/bin/python
  2. # -*- coding: utf-8 -*-
  3. # vim: set et ts=4 sts=4
  4. #
  5. # filename: ibus-table-speedmeter.py
  6. # 
  7. # display the typing speed
  8. #
  9. # ibus-table - The Tables engine for IBus
  10. #
  11. # Copyright (c) 2008-2009 Yu Yuwei <acevery@gmail.com>
  12. #
  13. # This library is free software; you can redistribute it and/or
  14. # modify it under the terms of the GNU Lesser General Public
  15. # License as published by the Free Software Foundation; either
  16. # version 2.1 of the License, or (at your option) any later version.
  17. #
  18. # This library is distributed in the hope that it will be useful,
  19. # but WITHOUT ANY WARRANTY; without even the implied warranty of
  20. # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  21. # Lesser General Public License for more details.
  22. #
  23. # You should have received a copy of the GNU Lesser General Public
  24. # License along with this library; if not, write to the Free Software
  25. # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  26. #
  27.  
  28. import pygtk
  29. pygtk.require('2.0')
  30. import gtk
  31. import gtk.gdk as gdk
  32. import dbus
  33. import dbus.service
  34. import dbus.mainloop.glib
  35. import time
  36. import threading
  37. import os.path as path
  38. import os 
  39. import sys
  40. import optparse
  41. import subprocess as sb
  42.  
  43. opt = optparse.OptionParser()
  44.  
  45. opt.add_option('--daemon','-d',
  46.         action = 'store_true',dest = 'daemon',default=False,
  47.         help = 'Run as daemon, default: %default')
  48.  
  49. (options, args) = opt.parse_args()
  50.  
  51. def daemonize(stdout='/dev/null', stderr=None, stdin='/dev/null',
  52.         pidfile=None ):
  53.     '''
  54.     This forks the current process into a daemon.
  55.     The stdin, stdout, and stderr arguments are file names that
  56.     will be opened and be used to replace the standard file descriptors
  57.     in sys.stdin, sys.stdout, and sys.stderr.
  58.     These arguments are optional and default to /dev/null.
  59.     Note that stderr is opened unbuffered, so
  60.     if it shares a file with stdout then interleaved output
  61.     may not appear in the order that you expect.
  62.     '''
  63.     # Do first fork.
  64.     try: 
  65.         pid = os.fork() 
  66.         if pid > 0: sys.exit(0) # Exit first parent.
  67.     except OSError, e: 
  68.         sys.stderr.write("fork #1 failed: (%d) %s\n" % (e.errno, e.strerror))
  69.         sys.exit(1)
  70.  
  71.     # Decouple from parent environment.
  72.     os.chdir("/") 
  73.     os.umask(0) 
  74.     os.setsid() 
  75.  
  76.     # Do second fork.
  77.     try: 
  78.         pid = os.fork()
  79.         if pid > 0: sys.exit(0) # Exit second parent.
  80.     except OSError, e: 
  81.         print 'second fork error'
  82.         sys.stderr.write("fork #2 failed: (%d) %s\n" % (e.errno, e.strerror))
  83.         sys.exit(1)
  84.  
  85.     # Open file descriptors and print start message
  86.     if not stderr: stderr = stdout
  87.     si = file(stdin, 'r')
  88.     so = file(stdout, 'w+')
  89.     se = file(stderr, 'a+', 0)
  90.     pid = str(os.getpid())
  91.     print "Start SpeedMeter with Pid: %s\n"  % pid
  92.     sys.stderr.flush()
  93.     if pidfile: file(pidfile,'w+').write("%s\n" % pid)
  94.  
  95.     # Redirect standard file descriptors.
  96.     sys.stdout.flush()
  97.     sys.stderr.flush()
  98.     os.dup2(si.fileno(), sys.stdin.fileno())
  99.     os.dup2(so.fileno(), sys.stdout.fileno())
  100.     os.dup2(se.fileno(), sys.stderr.fileno())
  101.  
  102. class Timer(threading.Thread):
  103.     '''add 0 to clist every second, clist must be a list of int'''
  104.     def __init__(self, accumulate):
  105.         super(Timer,self).__init__()
  106.         self.on = True
  107.         self.tlock = threading.RLock()
  108.         self.func = accumulate
  109.         self.sum = 0
  110.     
  111.     def run (self):
  112.         while self.on:
  113.             if self.sum == 0:
  114.                 # since we lock in func, so it is safe here
  115.                 self.func(0)
  116.             self.sum = (self.sum+1) % 5
  117.             time.sleep(0.2)
  118.     
  119.     def join(self):
  120.         self.on = False
  121.         super(Timer,self).join ()
  122.  
  123. class Handle(gtk.EventBox):
  124.     def __init__ (self):
  125.         super(Handle, self).__init__()
  126.         self.set_events(
  127.             gdk.BUTTON_PRESS_MASK | \
  128.             gdk.BUTTON_RELEASE_MASK | \
  129.             gdk.BUTTON1_MOTION_MASK)
  130.         self.connect("button_press_event",self.do_button_press_event)
  131.         self.connect("button_release_event",self.do_button_release_event)
  132.         self.connect("motion_notify_event",self.do_motion_notify_event)
  133.         self.__move_begined = False
  134.  
  135.     def do_button_press_event(self, widget, event, data=None):
  136.         if event.button == 1:
  137.             root = gdk.get_default_root_window()
  138.             try:
  139.                 desktop = root.property_get("_NET_CURRENT_DESKTOP")[2][0]
  140.                 self.__workarea = root.property_get("_NET_WORKAREA")[2][desktop * 4: (desktop + 1) * 4]
  141.             except:
  142.                 self.__workarea = None
  143.             self.__move_begined = True
  144.             toplevel = self.get_toplevel()
  145.             x, y = toplevel.get_position()
  146.             self.__press_pos = event.x_root - x, event.y_root - y
  147.             self.window.set_cursor(gdk.Cursor(gdk.FLEUR))
  148.             return True
  149.         return False
  150.  
  151.     def do_button_release_event(self, widget, event, data=None):
  152.         if event.button == 1:
  153.             self.__move_begined = False
  154.             del self.__press_pos
  155.             del self.__workarea
  156.             self.window.set_cursor(gdk.Cursor(gdk.HAND1))
  157.             return True
  158.  
  159.         return False
  160.  
  161.     def do_motion_notify_event(self, widget, event, data=None):
  162.         if not self.__move_begined:
  163.             return
  164.         toplevel = self.get_toplevel()
  165.         x, y = toplevel.get_position()
  166.         x  = int(event.x_root - self.__press_pos[0])
  167.         y  = int(event.y_root - self.__press_pos[1])
  168.  
  169.         if self.__workarea == None:
  170.             toplevel.move(x, y)
  171.             return
  172.  
  173.         if x < self.__workarea[0] and x > self.__workarea[0] - 16:
  174.             x = self.__workarea[0]
  175.         if y < self.__workarea[1] and y > self.__workarea[1] - 16:
  176.             y = self.__workarea[1]
  177.  
  178.         w, h = toplevel.get_size()
  179.         if x + w > self.__workarea[0] + self.__workarea[2] and \
  180.             x + w < self.__workarea[0] + self.__workarea[2] + 16:
  181.             x = self.__workarea[0] + self.__workarea[2] - w
  182.         if y + h > self.__workarea[1] + self.__workarea[3] and \
  183.             y + h < self.__workarea[1] + self.__workarea[3] + 16:
  184.             y =  self.__workarea[1] + self.__workarea[3] - h
  185.  
  186.         toplevel.move(x, y)
  187.  
  188. SPEED_METER_PATH="/org/ibus/table/SpeedMeter"
  189.  
  190. class SpeedMeter(dbus.service.Object):
  191.     '''Show the typing speed of user'''
  192.     method = lambda **args: \
  193.         dbus.service.method(dbus_interface = "org.ibus.table.SpeedMeter", \
  194.         **args)
  195.  
  196.     signal = lambda **args: \
  197.         dbus.service.signal(dbus_interface = "org.ibus.table.SpeedMeter", \
  198.         **args)
  199.  
  200.     def __init__(self, conn):
  201.         self.__conn = conn
  202.         self.__path = SPEED_METER_PATH
  203.         # initiate parent class
  204.         super(SpeedMeter, self).__init__(self.__conn, self.__path)
  205.         # list for caculate typing speed
  206.         self.list = [(0, time.time(), 0)]
  207.         # do gui part here
  208.         self.create_ui()
  209.         # timer
  210.         self.full = False
  211.         self.c_time = 0
  212.         self.timer = Timer(self.update_speed)
  213.         gdk.threads_enter()
  214.         self.timer.start()
  215.         gdk.threads_leave()
  216.         # showing
  217.         self.run ()
  218.  
  219.     # now define the service method
  220.  
  221.     @method(in_signature='i')
  222.     def Accumulate(self, phrase_len):
  223.         # start typing -> Accumulate(0)
  224.         # commit string -> Accumulate(len(string))
  225.         self.update_speed( phrase_len )
  226.  
  227.     @method()
  228.     def Reset(self):
  229.         self.reset()
  230.     
  231.  
  232.     @method()
  233.     def Quit(self):
  234.         self.quit ()
  235.  
  236.     @method()
  237.     def Show(self):
  238.         self.window.move(*self.pos)
  239.         self.window.show()
  240.  
  241.     @method()
  242.     def Hide(self):
  243.         self.pos = self.window.get_position()
  244.         self.window.hide()
  245.  
  246.     def quit( self ):
  247.         gtk.main_quit()
  248.         gdk.threads_leave()
  249.         self.timer.join()
  250.  
  251.     def quit_from_timer( self ):
  252.         gtk.main_quit()
  253.         gdk.threads_leave()
  254.  
  255.     def create_ui( self ):
  256.         self.window = gtk.Window(gtk.WINDOW_POPUP)
  257.         #self.window.connect("destroy", lambda w: gtk.main_quit() )
  258.         root = gdk.get_default_root_window()
  259.         try:
  260.             workarea = root.property_get("_NET_WORKAREA")[2]
  261.             right, bottom = workarea[2], workarea[3]
  262.         except:
  263.             right, bottom = root.get_size()
  264.         self.pos = right - 100, bottom -90
  265.         self.window.move(*self.pos)
  266.  
  267.         #self.window.set_decorated(False)
  268.         # provide grab & moving
  269.         self.event_box = Handle()
  270.         self.event_box.connect("button_press_event",self.do_button_press_event)
  271.         self.event_box.show()
  272.         self.window.add(self.event_box)
  273.         self.event_box.realize()
  274.         self.event_box.window.set_cursor(gdk.Cursor(gdk.HAND1))
  275.         # total frame 
  276.         self.frame = gtk.Frame()
  277.         self.frame.show()
  278.         self.event_box.add(self.frame)
  279.         # for vertical packing
  280.         self.vbox = gtk.VBox()
  281.         self.vbox.show()
  282.         self.frame.add(self.vbox)
  283.         # empty frame for decoration
  284.         self.frame1 = gtk.Frame()
  285.         self.frame1.show()
  286.         self.vbox.pack_start(self.frame1)
  287.         # color of speed label
  288.         self.label_color = gdk.Color(0,0,0xffff)
  289.         # speed label here
  290.         self.speed_label = gtk.Label()
  291.         self.speed_label.set_text('0')
  292.         # make the ratio of whole widget -> G
  293.         self.speed_label.set_size_request(81, 47)
  294.         self.speed_label.set_justify(gtk.JUSTIFY_CENTER)
  295.         self.speed_label.modify_fg(gtk.STATE_NORMAL,
  296.                 self.label_color)
  297.         self.speed_label.show()
  298.         self.vbox.pack_start(self.speed_label)
  299.         #self.window.set_resizable(False)
  300.         #self.window.show()
  301.     def run (self):
  302.         gdk.threads_enter()
  303.         gtk.main()
  304.  
  305.     def update_speed ( self, phrase_len ):
  306.         '''Update the output of SpeedMeter'''
  307.         now = time.time()
  308.         # only do lock here
  309.         self.timer.tlock.acquire()
  310.         self.list.append( (phrase_len, now) ) 
  311.         self.list = map (lambda x: (x[0], x[1], now - x[1]), self.list )
  312.         self.list = filter (lambda x: x[2] < 61, self.list)
  313.         # unlock here
  314.         self.timer.tlock.release()
  315.         if not self.full:
  316.             self.c_time = self.list[-1][1] - self.list[0][1] 
  317.             self.c_time = (self.c_time > 1 and self.c_time or 1 )
  318.             self.full = (self.c_time >=60)
  319.         speed = ( sum( map( lambda x: x[0], self.list) ) * 60\
  320.                 / self.c_time )
  321.         speed = int(speed)
  322.         # now we calculate the color,
  323.         # the color of HSV we want is from (240, 1, 1) -> (360, 1, 1)
  324.         # this is very easy, since S & V are both 1, only H need to take
  325.         # care.
  326.         # we want 10 -> 112 to be marked from blue to red
  327.         if speed > 10:
  328.             # speed > 10
  329.             if speed < 112:
  330.                 # 10 < speed < 112
  331.                 if speed >= 61:
  332.                     #  61 <= speed < 112
  333.                     # the blue is
  334.                     color = (112-speed) * 5
  335.                     self.label_color.red = 0xffff
  336.                     self.label_color.blue = (color << 8) + color
  337.                 else:
  338.                     # 10 < speed < 61
  339.                     # the red is
  340.                     color = (speed-10) * 5
  341.                     self.label_color.red = (color << 8) + color
  342.                     self.label_color.blue = 0xffff
  343.             else:
  344.                 # speed >= 112
  345.                     self.label_color.red = 0xffff
  346.                     self.label_color.blue = 0
  347.         else:
  348.             #speed <= 10:
  349.             self.label_color.red=0
  350.             self.label_color.blue = 0xffff
  351.         # update speed label
  352.         self.speed_label.set_text( "%d" % speed )
  353.         self.speed_label.modify_fg(gtk.STATE_NORMAL,
  354.                 self.label_color)
  355.  
  356.     def reset(self):
  357.         self.timer.tlock.acquire()
  358.         self.list = [(0, time.time(), 0)]
  359.         self.full = False
  360.         self.c_time = 0
  361.         self.timer.tlock.release()
  362.         self.update_speed(0)
  363.     
  364.     def do_button_press_event(self, widget, event, data=None):
  365.         if event.button == 3:
  366.             self.reset()
  367.             return True
  368.         return False
  369.  
  370. if __name__ == '__main__':
  371.     dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
  372.     bus = dbus.Bus()
  373.     user = path.basename( path.expanduser('~') )
  374.     name = "org.ibus.table.SpeedMeter.%s" % user
  375.     # check service name first
  376.     request = bus.request_name (name, dbus.bus.NAME_FLAG_DO_NOT_QUEUE)
  377.     if request != dbus.bus.REQUEST_NAME_REPLY_PRIMARY_OWNER:
  378.         sys.exit()
  379.     if options.daemon:
  380.         daemonize( '/dev/null', None, '/dev/null' )
  381.     busname = dbus.service.BusName( name, bus )
  382.     gdk.threads_init()
  383.     SpeedMeter(bus)
  384.  
  385.